package com.niit.scala

import scala.collection.mutable.{ArrayBuffer, ListBuffer}

object Base_06 {

  def main(args: Array[String]): Unit = {

    /*
      1.数组：
        1.1定长数据
        1.2变长数组
        1.3数组的修改
        1.4数组的遍历
     */
    //定长数组： 长度是不允许改变 val/var 变量名 = new Array[数据类型](长度)
    val arr1 = new Array[Int](10)
    val arr2 = Array(10,20,30,40,50)
    println(arr2(2))
    arr1(0) = 999
    println(arr1(0))

    //变长数组： 长度是允许改变
    val ab1 = ArrayBuffer[Int]()
    val ab2 = ArrayBuffer("Java","C/C++","HTML/CSS","MySQL")

    //数组的修改 增删改查
    //追加单个数据
    ab2 += "Spark"
    println(ab2)
    //追加多个数据
    ab2 ++= Array("JavaScript","BootStrap")
    println(ab2)
    //删除单个数据
    ab2 -= "C/C++"
    println(ab2)
    //删除多个数据
    ab2 --= Array("MySQL","Java")
    println(ab2)
    //修改数据
    ab2(1) = "Linux"
    println(ab2)

    //数组的遍历
       //方式一
      for ( i <- 0 to ab2.length-1 ){
        println(ab2(i))
      }
      //方式二
      for (i <- 0 until ab2.length){ //until ：左闭右开的区间
        println(ab2(i))
      }
      //方式三
      for (i <- ab2){ //i 就是数组中每一个值
        println(i)
      }

    /*
     2.元组： 元组一般用来存储不同类型的数据，并且长度和元素都不可变
        2.1 元组的定义
        2.2 访问元组中的元素
     */
      //元组的定义
      val tuple1 = ("张三",23,'a',10.35)
      println(tuple1)
      //访问元组中的元素
      tuple1._1  // 下划线 序号的方式访问元素
      println(tuple1._4)
      //遍历元素 。前提 先用元组生成一个迭代器对象，才能遍历
      val lt =  tuple1.productIterator
      for(i <- lt){
        println(i)
      }

    /*
     3.列表： 有序 且重复
        3.1不可变列表
        3.2可变列表
        3.3列表的基本操作
        3.4列表的扁平化
        3.5列表的拉链与拉开
        3.6列表的交并差
     */
    //不可变列表： 元素和长度都是不可变的
    var list1 = List(3,4,1,3,2,1,5,7,3)
    var list2 = Nil //创建一个不可变的空列表
    var list3 = 2 :: -1 :: Nil //该列表只有2个元素 2 和 -1
    println(list1,list2,list3)
    //可变列表
    var lb1 = ListBuffer[Int]()
    var lb2 = ListBuffer(1,3,4,2,3)
    //列表的基本操作
    //追加数据
    lb1 += 30
    lb1 ++= List(1,9,8,7,5,1)
    lb1 -= 1
    lb1 --= List(9,30)
    println(lb1)
    lb1(0) = 100
    println(lb1)
    //遍历列表
    for(i <- lb2) println(i)
    //可变列表转换为不可变列表
    val list4 = lb2.toList
    //列表转换为数组
    val arr3 = lb2.toArray
    //列表去重
    val lb3 = lb2.distinct
    println(lb3)
    //获得列表的首个元素 最后一个
    println(lb2.head)
    println(lb2.last)
    //获得列表除首个元素外的其他元素
    println(lb2.tail)
    //take:获得列表的前几个元素  drop:删除列表中的前几个元素
    val list5 = List(1,2,3,4,5,6,7,8)
    val list6 =  list5.take(3)
    println(list6)
    val list7 = list5.drop(3)
    println(list7)
    //列表的扁平化 嵌套在列表中的所有子列表，将子列表中的所有元素都单独放到一个新列表当中
    val list8 = List( List(1,2) , List(3,4),  List(5,6) )
    val list9 = list8.flatten
    println(list9)  //List(1, 2, 3, 4, 5, 6)

    //拉链 与 拉开
    //拉链：将两个列表，组成一个 元素为元组的列表。这个元组是两个列表中元素两两对应的结果
    val names = List("张三","李四","王五","马六")
    val ages = List(23,24,25)
    val list10 = names.zip(ages)
    println(list10) //List(  (张三,23),   (李四,24), (王五,25)  )
    //拉开 将一个包含元组的列表，拆解为一个元组包含两个列表（作为元组的元素）
    val list11 = list10.unzip
    println(list11)//( List(张三, 李四, 王五),List(23, 24, 25) )
    //列表的交 并 差
    val list12 = List(1,2,3,4)
    val list13 = List(3,4,5,6)
    //并集
    val union =  list12.union(list13)
    println(union)
    //交集
    val intersect = list12.intersect(list13)
    println(intersect)
    //差集
    val diff = list12.diff(list13)
    println(diff)


    /*
     4.集
      4.1不可变集
      4.2可变集
      4.3集的操作
     */
      //不可变集  特点：唯一 无序（添加的顺序和取出的顺序不一致）
      val set1 = Set[Int]() //不可变的空集
      val set2 = Set(9,8,7,6,5)
      println(set2)

      //可变集 要想要使用可变集，需要引包
    import scala.collection.mutable.Set
    var set3 = Set(7,8,9,4,5,6)
    println(set3)
    //集的基本操作
    var set4 = set3 - 8 //删除指定元素
    println(set4)
    var set5 = set3 + 1 //在追加一个元素
    println(set5)
    //集 也使用 += -= --= ++=

    /*
      映射 --> 字典 --> Map --> 键值对
       不可变Map
       可变Map
       Map的基本操作
     */
    //不可变Map
    var map1 = Map (  ("张三",23), ("李四",24),  ("王五",24)  )
    var map2 = Map ( "张三"-> 23 ,"李四"->24 ,  "王五"->25 )
    println(map1)
    println(map2)
    //可变Map 需要手动引包
    import scala.collection.mutable.Map
    var map3 = Map (  ("张三",23), ("李四",24),  ("王五",24)  )
    println(map3)
    //Map的修改
    map3("张三") = 30
    println(map3)
    //根据键获得值
    var age = map3.get("马六")//如果该键不存在，不会报错，而是返回None
    println(age)
    //获得所有键和所有值
    println("获得所有键：",map3.keys)
    println("获得所有值: ",map3.values)
    //遍历Map
    for ( (k,v) <- map3){ // list array tuple set装的元素都是单一的，而Map装的是一对的元素，所以在遍历的时候用(k,v)
      println(k,v)
    }

    /*
      迭代器：Scala针对每一类集合都提供一个迭代器，用来做集合遍历访问
      迭代器通常和while循环配合使用
      hasNext:查询迭代器中是否有下一个元素
      next：返回迭代器中下一个元素
     */
    var ll = List(1,2,3,4,5,6,7,8)
    val iterator =  ll.iterator
    while (iterator.hasNext){
      var i =  iterator.next()
      println(i)
    }


  }
}
